// pages/scoring/scoring.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    dormInfo: null,
    checkItems: [],
    currentItemIndex: 0,
    checkData: {
      items: [],
      totalScore: 0,
      comment: ''
    },
    isSubmitting: false,
    lastSubmitTimestamp: 0,
    isLoading: true,
    errorMsg: '',
    images: [],
    maxImageCount: 3,
    userInfo: {},

    excellentDormShowcaseImages: [],
    showExcellentDormUploadUI: false,
    maxExcellentDormImageCount: 4,
    excellentScoreThreshold: 90,
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 获取用户信息
    const userData = wx.getStorageSync('userData');
    if (!userData) {
      wx.redirectTo({
        url: '/pages/login/login'
      });
      return;
    }
    
    this.setData({
      userInfo: userData
    });
    
    // 初始化数据
    this.initData();
    
    // 如果有传入宿舍ID，直接加载
    if (options.dormId) {
      this.setData({
        dormId: options.dormId
      });
      this.loadDormInfo(options.dormId);
    }
  },

  // 获取用户信息
  getUserInfo: function() {
    const userData = wx.getStorageSync('userData');
    
    if (!userData) {
      wx.redirectTo({
        url: '/pages/login/login'
      });
      return;
    }
    
    this.setData({ userInfo: userData });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 每次显示页面时检查用户登录状态
    this.getUserInfo();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  // 处理swiper切换事件
  swiperChange: function(e) {
    const index = e.detail.current;
    
    // 保存当前项
    this.saveCurrentItem();
    
    // 更新当前索引和图片
    this.setData({
      currentItemIndex: index,
      images: this.data.checkData.items[index] ? (this.data.checkData.items[index].images || []) : []
    });
  },

  // 扫码获取宿舍ID
  scanDormCode: function() {
    wx.showLoading({
      title: '准备扫码',
    });
    
    setTimeout(() => {
      wx.hideLoading();
      
      wx.scanCode({
        scanType: ['qrCode'],
        success: res => {
          try {
            // 尝试解析扫码结果
            const qrData = res.result;
            
            // 解析不同格式的二维码
            let dormId = null;
            
            // 尝试匹配id参数
            const idMatch = qrData.match(/id=([^&]+)/);
            if (idMatch && idMatch[1]) {
              dormId = idMatch[1];
            }
            
            // 处理页面路径中带有参数的情况
            else if (qrData.includes('scene=')) {
              // 处理URL编码的scene参数
              const sceneMatch = qrData.match(/scene=([^&]+)/);
              if (sceneMatch && sceneMatch[1]) {
                // 解码scene参数
                const sceneContent = decodeURIComponent(sceneMatch[1]);
                const sceneIdMatch = sceneContent.match(/id=([^&]+)/);
                if (sceneIdMatch && sceneIdMatch[1]) {
                  dormId = sceneIdMatch[1];
                }
              }
            }
            
            if (dormId) {
              console.log('扫描到宿舍ID:', dormId);
              this.fetchDormInfo(dormId);
            } else {
              wx.showToast({
                title: '无效的宿舍二维码',
                icon: 'none'
              });
            }
          } catch (e) {
            console.error('扫码解析失败', e);
            wx.showToast({
              title: '扫码解析失败',
              icon: 'none'
            });
          }
        },
        fail: (err) => {
          console.error('扫码取消或失败', err);
        }
      });
    }, 200);
  },

  // 获取宿舍信息
  fetchDormInfo: function(dormId) {
    this.setData({
      isLoading: true,
      dormId: dormId
    });

    const db = wx.cloud.database();
    db.collection('dorms').doc(dormId).get().then(res => {
      if (res.data) {
        // 设置宿舍信息
        this.setData({
          dormInfo: res.data,
          'checkData.dormId': dormId,
          'checkData.building': res.data.building,
          'checkData.roomNo': res.data.roomNo,
          isLoading: false
        });

        // 初始化检查数据
        this.initCheckData();
        
        // 显示提示
        wx.showToast({
          title: '宿舍信息加载成功',
          icon: 'success'
        });
      } else {
        this.setData({
          errorMsg: '找不到该宿舍信息',
          isLoading: false
        });
      }
    }).catch(err => {
      console.error('获取宿舍信息失败', err);
      this.setData({
        errorMsg: '获取宿舍信息失败',
        isLoading: false
      });
    });
  },

  // 获取检查项目
  fetchCheckItems: function() {
    const db = wx.cloud.database();
    db.collection('checkItems')
      .where({
        isActive: true
      })
      .orderBy('order', 'asc')
      .get()
      .then(res => {
        if (res.data && res.data.length > 0) {
          this.setData({
            checkItems: res.data
          });

          // 初始化检查数据
          this.initCheckData();
        } else {
          this.setData({
            errorMsg: '未找到可用的检查项目'
          });
        }
      })
      .catch(err => {
        console.error('获取检查项目失败', err);
        this.setData({
          errorMsg: '获取检查项目失败'
        });
      });
  },

  // 初始化检查数据
  initCheckData: function() {
    // 确保宿舍信息和检查项都已经获取到
    if (this.data.dormInfo && this.data.checkItems.length > 0) {
      const checkItems = this.data.checkItems.map(item => {
        return {
          itemId: item._id,
          name: item.name,
          score: item.maxScore, // 默认满分
          maxScore: item.maxScore,
          images: [],
          comment: ''
        };
      });

      // 获取当前用户信息
      const userInfo = this.data.userInfo;
      
      this.setData({
        'checkData.items': checkItems,
        'checkData.checkerId': userInfo._id,
        'checkData.checkerName': userInfo.name,
        'checkData.checkDate': new Date(),
        'checkData.comment': '',
        'checkData.status': '已完成',
        images: [] // 当前项的图片
      });
      this.calculateTotalScore(); 
    }
  },

  // 计算总分
  calculateTotalScore: function() {
    let totalScore = 0;
    if (this.data.checkData && this.data.checkData.items) {
      this.data.checkData.items.forEach(item => {
        const scoreValue = Number(item.score); 
        totalScore += (isNaN(scoreValue) ? 0 : scoreValue); 
      });
    }
    this.setData({
      'checkData.totalScore': totalScore,
      showExcellentDormUploadUI: totalScore >= this.data.excellentScoreThreshold
    });
  },

  // 上一个检查项
  prevItem: function() {
    if (this.data.currentItemIndex > 0) {
      this.saveCurrentItem();
      this.setData({
        currentItemIndex: this.data.currentItemIndex - 1,
        images: this.data.checkData.items[this.data.currentItemIndex - 1].images || []
      });
    }
  },

  // 下一个检查项
  nextItem: function() {
    if (this.data.currentItemIndex < this.data.checkItems.length - 1) {
      this.saveCurrentItem();
      this.setData({
        currentItemIndex: this.data.currentItemIndex + 1,
        images: this.data.checkData.items[this.data.currentItemIndex + 1].images || []
      });
    }
  },

  // 保存当前检查项
  saveCurrentItem: function() {
    const currentIndex = this.data.currentItemIndex;
    const currentItem = this.data.checkData.items[currentIndex];
    
    // 更新图片
    currentItem.images = this.data.images;
    
    // 更新检查项
    const items = this.data.checkData.items;
    items[currentIndex] = currentItem;
    
    this.setData({
      'checkData.items': items
    });
    this.calculateTotalScore(); 
  },

  // 分数滑块改变
  scoreChange: function(e) {
    const score = parseInt(e.detail.value);
    const currentIndex = this.data.currentItemIndex;
    
    const items = this.data.checkData.items;
    items[currentIndex].score = score;
    
    this.setData({
      'checkData.items': items
    });
    this.calculateTotalScore(); 
  },

  // 评论输入
  commentInput: function(e) {
    const comment = e.detail.value;
    const currentIndex = this.data.currentItemIndex;
    
    const items = this.data.checkData.items;
    items[currentIndex].comment = comment;
    
    this.setData({
      'checkData.items': items
    });
  },

  // 总评输入
  overallCommentInput: function(e) {
    this.setData({
      'checkData.comment': e.detail.value
    });
  },

  // 上传图片
  uploadImage: function() {
    const maxCount = this.data.maxImageCount - this.data.images.length;
    
    if (maxCount <= 0) {
      wx.showToast({
        title: `最多上传${this.data.maxImageCount}张图片`,
        icon: 'none'
      });
      return;
    }
    
    wx.chooseMedia({
      count: maxCount,
      mediaType: ['image'],
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: res => {
        const tempFiles = res.tempFiles;
        const tempFilePaths = tempFiles.map(file => file.tempFilePath);
        
        // 显示上传提示
        wx.showLoading({
          title: '正在上传...',
          mask: true
        });
        
        // 上传图片到云存储
        const uploadTasks = tempFilePaths.map(filePath => this.uploadFile(filePath));
        
        Promise.all(uploadTasks).then(fileIDs => {
          const newImages = [...this.data.images, ...fileIDs];
          this.setData({
            images: newImages
          });
          wx.hideLoading();
          
          if (fileIDs.length > 0) {
            wx.showToast({
              title: '上传成功',
              icon: 'success'
            });
          }
        }).catch(() => {
          wx.hideLoading();
          wx.showToast({
            title: '上传图片失败',
            icon: 'none'
          });
        });
      }
    });
  },

  // 上传单个文件
  uploadFile: function(filePath) {
    wx.showLoading({
      title: '上传中...',
    });
    
    const cloudPath = `checks/${this.data.dormInfo.building}-${this.data.dormInfo.roomNo}/${Date.now()}-${Math.random().toString(36).substr(2)}.${filePath.match(/\.([^.]+)$/)[1]}`;
    
    return wx.cloud.uploadFile({
      cloudPath,
      filePath
    }).then(res => {
      wx.hideLoading();
      return res.fileID;
    }).catch(err => {
      wx.hideLoading();
      console.error('上传文件失败', err);
      throw err;
    });
  },

  // 删除图片
  deleteImage: function(e) {
    const index = e.currentTarget.dataset.index;
    const images = [...this.data.images];
    images.splice(index, 1);
    
    this.setData({
      images
    });
  },

  // 预览图片
  previewImage: function(e) {
    const index = e.currentTarget.dataset.index;
    
    wx.previewImage({
      current: this.data.images[index],
      urls: this.data.images
    });
  },

  // 提交评分
  submitScoring: function() {
    // 检查是否正在提交中
    if (this.data.isSubmitting) {
      wx.showToast({
        title: '正在提交中...',
        icon: 'none',
        duration: 1500
      });
      return;
    }

    // 检查距离上次成功提交是否小于5秒
    const currentTime = Date.now();
    if (currentTime - this.data.lastSubmitTimestamp < 5000) {
      wx.showToast({
        title: '操作过于频繁，请稍候',
        icon: 'none',
        duration: 2000
      });
      return;
    }

    // 保存当前项
    this.saveCurrentItem();

    // 验证是否所有必要项都已评分
    if (!this.validateForm()) {
      return;
    }

    wx.showModal({
      title: '确认提交',
      content: `您即将提交对${this.data.dormInfo.building}栋${this.data.dormInfo.roomNo}宿舍的评分，总分为${this.data.checkData.totalScore}分，确认提交吗？`,
      confirmColor: '#07c160',
      success: (res) => {
        if (res.confirm) {
          // 只在用户确认后设置提交状态
          this.setData({ isSubmitting: true });
          this.performSubmit();
        }
      }
    });
  },
  
  // 执行提交
  performSubmit: async function() {
    wx.showLoading({
      title: '提交中...',
      mask: true
    });
  
    try {
      // 准备提交数据
      const checkData = this.prepareCheckData();
  
      // 初始化优秀宿舍展示图片文件ID数组
      let showcaseImageFileIDs = [];
  
      // 如果需要显示优秀宿舍上传UI并且有图片待上传
      if (this.data.showExcellentDormUploadUI && this.data.excellentDormShowcaseImages.length > 0) {
        wx.showLoading({
          title: '上传展示图...',
          mask: true
        });
  
        const uploadPromises = this.data.excellentDormShowcaseImages.map(async (imagePath) => {
          const timestamp = Date.now();
          const randomStr = Math.random().toString(36).substr(2);
          const extensionMatch = imagePath.match(/\.\w+$/);
          const extension = extensionMatch ? extensionMatch[0] : '.jpg';
          const cloudPath = `dorms/showcase/${this.data.dormId}/${timestamp}-${randomStr}${extension}`;
  
          try {
            const uploadResult = await wx.cloud.uploadFile({
              cloudPath: cloudPath,
              filePath: imagePath,
            });
            return uploadResult.fileID;
          } catch (uploadError) {
            console.error('优秀宿舍图片上传失败:', uploadError, '路径:', imagePath);
            return null;
          }
        });
  
        const results = await Promise.all(uploadPromises);
        showcaseImageFileIDs = results.filter(id => id !== null);
  
        wx.hideLoading(); // 隐藏上传展示图的loading
  
        if (showcaseImageFileIDs.length !== this.data.excellentDormShowcaseImages.length) {
          wx.showToast({
            title: '部分展示图上传失败',
            icon: 'none',
            duration: 2000
          });
          // 根据业务逻辑，这里可以决定是否因为部分图片上传失败而中断提交流程
          // 如果需要中断，可以 throw new Error('部分展示图上传失败，已取消提交');
        }
      }
  
      // 将showcaseImageFileIDs添加到提交数据中
      checkData.showcaseImageFileIDs = showcaseImageFileIDs;
      console.log('提交评分数据', JSON.stringify(checkData));
  
      // 提交数据到云数据库
      const res = await wx.cloud.callFunction({
        name: 'saveCheck',
        data: {
          check: checkData
        }
      });
  
      console.log('评分提交结果', res);
  
      if (res.result && res.result.success) {
        // 云函数明确表示成功
        // checkId 可以在后续需要时使用
        this.finishSubmit('评分提交成功'); // finishSubmit 内部会更新 lastSubmitTimestamp 和 isSubmitting
  
        // 等保存成功后，尝试更新宿舍状态和任务 (这里的逻辑可以保持)
        setTimeout(() => {
          wx.cloud.callFunction({
            name: 'cleanupAndResetTasks',
            data: {
              dormId: this.data.dormId,
              checkData: checkData // 注意: 此处传递的 checkData 是调用云函数前的，可能与数据库中的有细微时间差
            }
          }).then(() => {
            console.log('任务更新成功');
          }).catch(taskErr => { // 给 catch 参数命名，避免与外层 err 混淆
            console.error('更新宿舍状态失败', taskErr);
          });
        }, 1000);
  
      } else if (res.result && res.result.isDuplicate === true) {
        // 云函数明确告知是重复提交
        wx.hideLoading(); // 确保 loading 状态被清除
        wx.showToast({
          title: res.result.error || '请勿重复提交',
          icon: 'none',
          duration: 2500
        });
        // 即使是后端报重复，前端也应该认为这次"提交尝试"已经结束，更新时间戳和状态以启用防抖
        this.setData({ isSubmitting: false, lastSubmitTimestamp: Date.now() });
      } else {
        // 其他类型的云函数执行失败或未明确成功的业务逻辑
        throw new Error(res.result?.error || '提交操作失败，请稍后重试');
      }
  
    } catch (err) { // 这个 catch 捕获 try 块中的所有错误，包括 throw new Error 和 wx.cloud.callFunction 的网络错误等
      console.error('评分提交或处理过程中发生错误:', err); // 更明确的错误日志
      wx.hideLoading(); // 确保在任何错误路径下都隐藏loading
      this.setData({ isSubmitting: false }); // 确保重置提交状态
  
      let errorMsg = '提交失败，请检查网络或稍后重试'; // 更通用的默认错误提示
      if (err && err.message) {
        errorMsg = err.message;
      } else if (err && typeof err === 'string') {
        errorMsg = err;
      }
      // 可以根据 err.errMsg 或其他特定错误码进一步细化提示
      // 例如，如果 err.errMsg 包含 'cloud function execution error'，可以提示联系管理员
  
      wx.showToast({
        title: errorMsg,
        icon: 'none',
        duration: 3000
      });
    }
  },
  
  // 完成提交流程
  finishSubmit: function(message) {
    this.setData({ 
      isSubmitting: false,
      lastSubmitTimestamp: Date.now() 
    });
    wx.hideLoading();
    
    // 显示结果
    wx.showToast({
      title: message,
      icon: 'success',
      duration: 2000
    });
    
    // 延迟返回上一页
    setTimeout(() => {
      wx.navigateBack();
    }, 2000);
  },

  // 验证表单
  validateForm: function() {
    // 检查是否有寝室信息
    if (!this.data.dormInfo) {
      wx.showToast({
        title: '请先扫描寝室二维码',
        icon: 'none'
      });
      return false;
    }
    
    // 检查每个检查项是否填写了分数
    for (const item of this.data.checkData.items) {
      if (item.score === undefined || item.score === null) {
        wx.showToast({
          title: `请为${item.name}评分`,
          icon: 'none'
        });
        return false;
      }
    }
    
    return true;
  },

  // 准备提交数据
  prepareCheckData: function() {
    // 确保用户信息完整
    if (!this.data.userInfo || !this.data.userInfo.openid) {
      throw new Error('用户信息不完整，请重新登录');
    }
    
    // 确保宿舍信息完整
    if (!this.data.dormId || !this.data.dormInfo) {
      throw new Error('宿舍信息不完整，请重新扫码');
    }
    
    // 确保评分项完整
    if (!this.data.checkData.items || this.data.checkData.items.length === 0) {
      throw new Error('评分项为空，请刷新页面重试');
    }
    
    // 确保总分计算正确
    if (this.data.checkData.totalScore === undefined || this.data.checkData.totalScore === null) {
      throw new Error('总分计算错误，请刷新页面重试');
    }
    
    // 打印用户信息，用于调试
    console.log('评分用户信息:', this.data.userInfo);
    
    return {
      dormId: this.data.dormId,
      building: this.data.dormInfo.building || '',
      roomNo: this.data.dormInfo.roomNo || '',
      checkerId: this.data.userInfo.openid || '',
      checkerName: this.data.userInfo.name || '未知用户',
      // 添加用户角色和名称信息，用于开发阶段的权限检查
      userRole: this.data.userInfo.role || '宿管', // 默认为宿管，确保权限检查通过
      userName: this.data.userInfo.name || '开发测试用户',
      checkDate: new Date(),
      totalScore: this.data.checkData.totalScore || 0,
      items: this.data.checkData.items.map(item => ({
        itemId: item.itemId || '',
        name: item.name || '',
        score: Number(item.score) || 0,
        maxScore: Number(item.maxScore) || 0,
        comment: item.comment || '',
        images: item.images || []
      })),
      comment: this.data.checkData.comment || '',
      status: '已完成'
    };
  },

  chooseExcellentDormImage: function() {
    const count = this.data.maxExcellentDormImageCount - this.data.excellentDormShowcaseImages.length;
    if (count <= 0) {
      wx.showToast({ title: `最多上传${this.data.maxExcellentDormImageCount}张优秀宿舍照片`, icon: 'none' });
      return;
    }
    wx.chooseImage({
      count: count,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: res => {
        this.setData({
          excellentDormShowcaseImages: this.data.excellentDormShowcaseImages.concat(res.tempFilePaths)
        });
      },
      fail: err => {
        console.log("chooseExcellentDormImage failed", err);
        wx.showToast({ title: '图片选择失败', icon: 'none' });
      }
    });
  },

  previewExcellentDormImage: function(e) {
    wx.previewImage({
      current: this.data.excellentDormShowcaseImages[e.currentTarget.dataset.index],
      urls: this.data.excellentDormShowcaseImages
    });
  },

  deleteExcellentDormImage: function(e) {
    const index = e.currentTarget.dataset.index;
    const images = [...this.data.excellentDormShowcaseImages];
    images.splice(index, 1);
    this.setData({
      excellentDormShowcaseImages: images
    });
  },

  // 初始化数据
  initData: function() {
    // 获取检查项目
    this.fetchCheckItems();
  },
  
  // 扫描二维码
  scanQRCode: function() {
    wx.scanCode({
      scanType: ['qrCode'],
      success: res => {
        try {
          // 尝试解析扫码结果
          const qrData = res.result;
          
          // 解析不同格式的二维码
          let dormId = null;
          
          // 尝试匹配id参数
          const idMatch = qrData.match(/id=([^&]+)/);
          if (idMatch && idMatch[1]) {
            dormId = idMatch[1];
          } 
          // 或者尝试直接使用结果作为ID
          else if (qrData.match(/^[a-zA-Z0-9]{16,24}$/)) {
            dormId = qrData;
          }
          
          if (!dormId) {
            wx.showToast({
              title: '无效的宿舍二维码',
              icon: 'none'
            });
            return;
          }
          
          // 保存宿舍ID并获取详情
          this.setData({
            dormId: dormId
          });
          
          this.loadDormInfo(dormId);
        } catch (err) {
          console.error('二维码解析失败', err);
          wx.showToast({
            title: '无效的二维码格式',
            icon: 'none'
          });
        }
      },
      fail: err => {
        console.log('扫码取消或失败', err);
      }
    });
  },
  
  // 加载宿舍信息
  loadDormInfo: function(dormId) {
    this.setData({ isLoading: true });
    
    wx.showLoading({
      title: '加载宿舍信息',
    });
    
    wx.cloud.callFunction({
      name: 'manageDorms',
      data: {
        action: 'get',
        data: {
          dormId: dormId
        }
      }
    }).then(res => {
      wx.hideLoading();
      
      if (res.result && res.result.success && res.result.dorm) {
        const dormInfo = res.result.dorm;
        
        this.setData({
          dormInfo: dormInfo,
          isLoading: false,
          // 如果宿舍分数在90分以上，显示上传优秀宿舍图片的UI
          showExcellentDormUploadUI: dormInfo.currentScore >= this.data.excellentScoreThreshold
        });
      } else {
        this.setData({
          isLoading: false,
          errorMsg: '宿舍信息获取失败'
        });
        
        wx.showToast({
          title: '宿舍信息获取失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('获取宿舍信息失败', err);
      this.setData({
        isLoading: false,
        errorMsg: '获取宿舍信息失败'
      });
      
      wx.hideLoading();
      wx.showToast({
        title: '宿舍信息获取失败',
        icon: 'none'
      });
    });
  },

  // 获取检查项目
  fetchCheckItems: function() {
    const db = wx.cloud.database();
    
    db.collection('checkItems')
      .orderBy('order', 'asc')
      .get()
      .then(res => {
        const items = res.data;
        
        if (!items || items.length === 0) {
          this.setData({
            errorMsg: '检查项目不存在',
            isLoading: false
          });
          return;
        }
        
        // 初始化评分数据
        const checkItems = [];
        const checkDataItems = [];
        
        items.forEach(item => {
          checkItems.push(item);
          
          // 初始化评分项
          checkDataItems.push({
            itemId: item._id,
            name: item.name,
            score: 0, // 初始分数为0
            maxScore: item.maxScore,
            comment: '',
            images: []
          });
        });
        
        this.setData({
          checkItems: checkItems,
          'checkData.items': checkDataItems,
          isLoading: false
        });
      })
      .catch(err => {
        console.error('获取检查项目失败', err);
        this.setData({
          errorMsg: '获取检查项目失败',
          isLoading: false
        });
      });
  },
});